Introdução

---

A partir do arquivo do kaggle (https://www.kaggle.com/christianlillelund/csgo-round-winner-classification) publicado pelo usuário Christian Lillelund, o objetivo é conseguir classficiar o final de um round ou seja o vencedor dela, a partir das variaveis dispostas em um determinado momento do jogo.

Sobre o jogo CS GO é um jogo de tiro em primeira pessoa que os jogadores são separados em dois grupos, os Terroristas e os Contra Terroristas. O objetivo dos terroristas é implantar a bomba e detoná-las antes que o round de dois minutos acabe. Os contra-terroristas tem que impedir que isso aconteça. A partida tem trinta rounds e o aquele que tiver a maioria, ou seja, aquele que conseguir vencer primeiro 16 rounds vence.

import sys

import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns

sys.path.append("./utils")

Nos arquivos importados acima fizemos a separação das armas em grupos, em vez de termos uma coluna por arma, o que deixaria o nosso modelo muito complexo desnecessariamente.

import loader
import round_classifier
from Parser import Parser

all_data = loader.load_dataset()

Aqui acima é possível notar o data set puro tem uma quantidade enorme de colunas 97, sendo que a grande maioria não é de grande importância para o modelo. Por isso posteriormente iremos selecionar melhor elas.

all_columns = all_data.columns
len(all_data.columns)

97

Entre as colunas, existe a coluna específica de cada arma que pode ser utilizada no jogo, assim como a granada escolhida, sendo o seu valor vai de 0 a 5 (depende de quantas estão sendo utilizadas pela equipe). Para o nosso projeto agrupou-se as armas em categorias de armas: “sec” rifles, main rifles, normal force weapons, weak pistol e extra strong pistols. Isso foi feito na função Parser().

parser = Parser()
# treat_data = all_data.copy()
treat_data = parser.classify_weapons(all_data.copy())
# treat_data = parser.create_round_winner_columns(treat_data.copy())

Além disso, criamos a categoria “eco". No jogo, as armas são compradas com o dinheiro do jogo ganho a cada round. Em alguns casos, os jogadores como equipe optam por economizar em um round para investir o dinheiro no próximo round, ou seja, não compram nenhuma arma no round. Essa categoria foi criada pois a tendência é quando o grupo escolhe o eco round normalmente perde e pode ser um bom feature para o modelo.

A categoria “pistol round” foi criada pois o primeiro round do jogo e o round 16, de troca de lado, acontecem de pistola. Por serem rounds iniciais (primeiro round do jogo e o round em que os jogadores estão jogando pela primeira vez por uma outra classe) não tem dinheiro o suficiente para comprar armas e o jogo acontece com pistolas.

Já a categoria “force” acontece quando os jogadores têm pouco dinheiro e mesmo se tentassem jogar um eco round (economizando para o próximo) não teriam o suficiente para comprar armas boas no próximo round. Eles então são forçados a comprar armas mais baratas e piores, e tentam ganhar o jogo dessa maneira. Sendo isso, seria importante identificar essa categoria, visto que pode ser um grande indicativo de derrota.

# Define rounds pistol (ocorrem no começo do jogo e no round 16)
treat_data["pistol_round"] = treat_data.apply(
    round_classifier.define_pistol_round, axis=1
)

# Defining eco rounds
treat_data["ct_eco"] = treat_data.apply(round_classifier.define_full_ct_eco, axis=1)
treat_data["t_eco"] = treat_data.apply(round_classifier.define_full_t_eco, axis=1)

# Defining force buy rounds
treat_data["ct_force"] = treat_data.apply(
    round_classifier.define_force_ct_round, axis=1
)
treat_data["t_force"] = treat_data.apply(round_classifier.define_force_t_round, axis=1)

Aqui selecionamos as colunas do dataset que julgamos ter mais relevancia para o modelo, além de algumas que filtramos após analisar a feature importance do modelo selecionado. Além disso tiramos as colunas que tinhamos resumido posteriormente, restando apenas 36 colunas

# Selecting columns
normal_columns = all_columns[0:16].tolist()
made_columns_t = [
    "t_main_rifle",
    "t_sec_rifle",
    "t_force_weapons",
    "t_weak_pistols",
    "t_strong_pistols",
    "t_granades",
    "t_weapon_awp",
    "t_eco",
    "t_force",
]
made_columns_ct = [
    "ct_main_rifle",
    "ct_sec_rifle",
    "ct_force_weapons",
    "ct_weak_pistols",
    "ct_strong_pistols",
    "ct_granades",
    "ct_weapon_awp",
    "ct_eco",
    "ct_force",
]
extra_columns = [
    "pistol_round",
    "round_winner",
]
selected_columns = normal_columns + made_columns_ct + made_columns_t + extra_columns

# Getting only columns selected columns
final_df = treat_data[selected_columns]
# checando nans
final_df

	time_left	ct_score	t_score	map	bomb_planted	ct_health	t_health	ct_armor	t_armor	ct_money	...	t_sec_rifle	t_force_weapons	t_weak_pistols	t_strong_pistols	t_granades	t_weapon_awp	t_eco	t_force	pistol_round	round_winner
0	175.00	0.0	0.0	de_dust2	False	500.0	500.0	0.0	0.0	4000.0	...	0.0	0.0	0.0	0.0	0.0	0.0	0	0	1	CT
1	156.03	0.0	0.0	de_dust2	False	500.0	500.0	400.0	300.0	600.0	...	0.0	0.0	0.0	0.0	2.0	0.0	0	0	1	CT
2	96.03	0.0	0.0	de_dust2	False	391.0	400.0	294.0	200.0	750.0	...	0.0	0.0	0.0	0.0	2.0	0.0	0	0	1	CT
3	76.03	0.0	0.0	de_dust2	False	391.0	400.0	294.0	200.0	750.0	...	0.0	0.0	0.0	0.0	0.0	0.0	0	0	1	CT
4	174.97	1.0	0.0	de_dust2	False	500.0	500.0	192.0	0.0	18350.0	...	0.0	0.0	0.0	0.0	0.0	0.0	1	0	0	CT
...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...
122405	15.41	11.0	14.0	de_train	True	200.0	242.0	195.0	359.0	100.0	...	0.0	0.0	2.0	0.0	3.0	1.0	0	0	0	T
122406	174.93	11.0	15.0	de_train	False	500.0	500.0	95.0	175.0	11500.0	...	0.0	0.0	0.0	0.0	2.0	1.0	0	0	0	T
122407	114.93	11.0	15.0	de_train	False	500.0	500.0	495.0	475.0	1200.0	...	0.0	0.0	0.0	1.0	14.0	1.0	0	0	0	T
122408	94.93	11.0	15.0	de_train	False	500.0	500.0	495.0	475.0	1200.0	...	0.0	0.0	0.0	1.0	12.0	1.0	0	0	0	T
122409	74.93	11.0	15.0	de_train	False	375.0	479.0	395.0	466.0	1100.0	...	0.0	0.0	0.0	1.0	8.0	1.0	0	0	0	T

122410 rows × 36 columns

len(final_df.columns)

36

Aqui udamos a variavel dependente de uma string "CT" ou "T" para uma binária (1 ou 0).

def round_winner_binnary(dataframe):
    round_winner_bin = []
    for i in range(0, len(dataframe.index)):
        if dataframe["round_winner"].iloc[i] == "CT":
            round_winner_bin.append(1)
        elif dataframe["round_winner"].iloc[i] == "T":
            round_winner_bin.append(0)
    dataframe["roundwinner_bin"] = round_winner_bin


round_winner_binnary(final_df)

C:\Users\luca\AppData\Local\Temp/ipykernel_26344/2013146941.py:8: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
  dataframe["roundwinner_bin"] = round_winner_bin

Separando variável dependente

from sklearn.compose import ColumnTransformer
from sklearn.impute import SimpleImputer
from sklearn.metrics import confusion_matrix, mean_squared_error
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import OneHotEncoder, StandardScaler

labels = final_df["roundwinner_bin"].copy()

Selecionando variáveis categóricas e passando elas para type category

cat_attribs = [
    "map",
    "bomb_planted",
    "ct_eco",
    "ct_force",
    "t_eco",
    "t_force",
    "pistol_round",
    "ct_helmets",
    "t_helmets",
    "ct_defuse_kits",
    "ct_players_alive",
    "t_players_alive",
    "ct_main_rifle",
    "ct_sec_rifle",
    "ct_force_weapons",
    "ct_weak_pistols",
    "ct_strong_pistols",
    "ct_weapon_awp",
    "t_main_rifle",
    "t_sec_rifle",
    "t_force_weapons",
    "t_weak_pistols",
    "t_strong_pistols",
    "t_weapon_awp",
]

for col in cat_attribs:
    final_df[col] = final_df[col].astype("category")

C:\Users\luca\AppData\Local\Temp/ipykernel_26344/61044880.py:29: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
  final_df[col] = final_df[col].astype("category")

Selecionando variáveis numéricas e passando o data set pela pipline.

• Standard Scaler para variáveis numéricas.
• One Hot Encoding para variáveis categóricas.

# meu_imputer = SimpleImputer(strategy="median")
meu_scaler = StandardScaler()

num_pipeline = Pipeline(
    [
        ("std_scaler", meu_scaler),
    ]
)

meu_one_hot_encoder = OneHotEncoder(sparse=False)

cat_pipeline = Pipeline(
    [
        ("cat_encoder", meu_one_hot_encoder),
    ]
)


dataset_num = final_df.drop(
    labels=[
        "map",
        "bomb_planted",
        "ct_eco",
        "ct_force",
        "t_eco",
        "t_force",
        "pistol_round",
        "ct_helmets",
        "t_helmets",
        "ct_defuse_kits",
        "ct_players_alive",
        "t_players_alive",
        "ct_main_rifle",
        "ct_sec_rifle",
        "ct_force_weapons",
        "ct_weak_pistols",
        "ct_strong_pistols",
        "ct_weapon_awp",
        "t_main_rifle",
        "t_sec_rifle",
        "t_force_weapons",
        "t_weak_pistols",
        "t_strong_pistols",
        "t_weapon_awp",
        "round_winner",
        "roundwinner_bin",
    ],
    axis=1,
)
num_attribs = list(dataset_num)

cat_attribs = [
    "map",
    "bomb_planted",
    "ct_eco",
    "ct_force",
    "t_eco",
    "t_force",
    "pistol_round",
    "ct_helmets",
    "t_helmets",
    "ct_players_alive",
    "t_players_alive",
    "ct_force_weapons",
    "ct_weak_pistols",
    "ct_strong_pistols",
    "ct_weapon_awp",
    "t_main_rifle",
    "t_sec_rifle",
    "t_force_weapons",
    "t_weak_pistols",
    "t_strong_pistols",
    "t_weapon_awp",
]

full_pipeline = ColumnTransformer(
    [
        ("num", num_pipeline, num_attribs),
        ("cat", cat_pipeline, cat_attribs),
    ]
)
x_raw = final_df.drop(columns=["round_winner", "roundwinner_bin"])

dataset_prepared = full_pipeline.fit_transform(x_raw)

Separando dados entre treinamento e teste (tamanho do conjunto teste de 33,3% do total)

from sklearn.model_selection import train_test_split

seed = 42
X = dataset_prepared
X_train, X_test, y_train, y_test = train_test_split(
    X, labels, test_size=0.333, random_state=seed
)
X_t, X_te, y_t, y_te = train_test_split(
    x_raw, labels, test_size=0.333, random_state=seed
)

Fizemos assim a comparação entre três modelos diferentes de classificador, para determinar qual é o melhor para o nosso conjunto de dados. Sendo que todos foram testados com cross validation(cv = 3).

Random Forest Classifier

from sklearn.ensemble import RandomForestClassifier

rf_classifier = RandomForestClassifier(
    n_estimators=350, n_jobs=-1, random_state=seed, max_features="auto"
)
rf_classifier.fit(X_train, y_train)

RandomForestClassifier(n_estimators=350, n_jobs=-1, random_state=42)

from sklearn.model_selection import cross_val_score

cross_val_score(
    rf_classifier,
    X_train,
    y_train,
    cv=3,
    scoring="accuracy",
    n_jobs=-1,
)

array([0.84020429, 0.85034539, 0.84449752])

SGD Classifier

from sklearn.linear_model import SGDClassifier

# Existe aleatoriedade dentro do SGDClassifier, por isso o argumento
RANDOM_SEED = 420
sgd_clf = SGDClassifier(
    max_iter=500,
    tol=1e-3,
    random_state=RANDOM_SEED,
)
sgd_clf.fit(X_train, y_train)
y_pred_sgd = rf_classifier.predict(X_test)
y_pred_sgd

array([1, 0, 1, ..., 0, 1, 0], dtype=int64)

from sklearn.model_selection import cross_val_score

cross_val_score(
    sgd_clf,
    X_train,
    y_train,
    cv=3,
    scoring="accuracy",
    n_jobs=-1,
)

array([0.74775867, 0.74875073, 0.74870476])

Naive Bayes

from sklearn.naive_bayes import GaussianNB

# Create a Gaussian Classifier
gaussianN = GaussianNB()

# Train the gaussianN using the training sets
gaussianN.fit(X_train, y_train)

# Predict Output
predicted = gaussianN.predict(X_test)  # 0:Overcast, 2:Mild
predicted

array([1, 1, 1, ..., 0, 0, 0], dtype=int64)

cross_val_score(
    gaussianN,
    X_train,
    y_train,
    cv=3,
    scoring="accuracy",
    n_jobs=-1,
)

array([0.68334803, 0.68639771, 0.68767224])

Com todos os modelos rodados agora fizemos a comparação entre os três por meio dos parametros accuracy,precision e recall.

Escolha do melhor modelo

from sklearn import metrics


def get_results(models, X_test, y_test):
    results = []
    for model in models:
        y_pred = model["model"].predict(X_test)
        result = {
            "Name": model["name"],
            "Accuracy": metrics.accuracy_score(y_test, y_pred),
            "Precision": metrics.precision_score(y_test, y_pred),
            "Recall": metrics.recall_score(y_test, y_pred),
        }
        results.append(result)
    _df = pd.DataFrame(results)
    _df.set_index("Name", inplace=True)
    return _df

Accuracy, Precision e Recall dos modelos testados

Antes de entrar em detalhes sobre a performance dos modelos, é importante esclarecer algumas métricas dentro do contexto dos nossos dados:

• True Positives: o modelo previu um output positivo (round winner = 1) quando a equipe de fato venceu a partida.
• True Negatives: o modelo previu um output negativo (round winner = 0) quando a equipe de fato não venceu a partida.
• False Positives: o modelo previu um output positivo (round winner = 1) quando a equipe na verdade não venceu a partida.
• False Negatives: o modelo previu um output negativo (round winner = 0) quando a equipe na verdade venceu a partida.

Nesse sentido, as seguintes métricas de Accuracy, Precision e Recall foram calculadas seguindo as fórmulas:

• Precision: TruePositives / ( TruePositives + False Positives )
• Recall: TruePositives / ( TruePositives + False Negatives )
• Accuracy: ( TruePositives + TrueNegatives ) / ( TruePositives + FalsePositives + TrueNegatives + FalseNegatives )

models = [
    {
        "name": "Random Forest Classifier",
        "model": rf_classifier,
    },
    {
        "name": "SGD Classifier",
        "model": sgd_clf,
    },
    {
        "name": "Naive Bayes",
        "model": gaussianN,
    },
]
df_test_results = get_results(models, X_test, y_test)
df_test_results

	Accuracy	Precision	Recall
Name
Random Forest Classifier	0.871280	0.866120	0.873586
SGD Classifier	0.749332	0.714572	0.817330
Naive Bayes	0.711797	0.671376	0.812148

grouped_df_rf = df_test_results.query("Name == 'Random Forest Classifier'")
grouped_df_sgd = df_test_results.query("Name == 'SGD Classifier'")
grouped_df_nb = df_test_results.query("Name == 'Naive Bayes'")

Comparação entre os três modelos com a Accuracy

import plotly.graph_objects as go

fig = go.Figure(
    layout=go.Layout(
        title="Accurácia Dos Modelos",
    )
)
fig.add_trace(
    go.Bar(
        x=grouped_df_rf["Accuracy"],
        name="Accuracy - Random Forest Classifier",
    ),
)
fig.add_trace(
    go.Bar(
        x=grouped_df_nb["Accuracy"],
        name="Accuracy - SGD Classifier",
    )
)

fig.add_trace(
    go.Bar(
        x=grouped_df_sgd["Accuracy"],
        name="Accuracy - Naive Bayes",
    )
)

fig.show()

Comparação entre os três modelos com a Precision

fig = go.Figure(
    layout=go.Layout(
        title="Precisão Dos Modelos",
    )
)
fig.add_trace(
    go.Bar(
        x=grouped_df_rf["Precision"],
        name="Precision - Random Forest Classifier",
    )
)
fig.add_trace(
    go.Bar(
        x=grouped_df_nb["Precision"],
        name="Precision - SGD Classifier",
    )
)
fig.add_trace(
    go.Bar(
        x=grouped_df_sgd["Precision"],
        name="Precision - Naive Bayes",
    )
)

fig.show()

Comparação entre os três modelos com o Recall

fig = go.Figure(
    layout=go.Layout(
        title="Recall Dos Modelos",
    )
)
fig.add_trace(
    go.Bar(
        x=grouped_df_rf["Recall"],
        name="Recall - Random Forest Classifier",
    )
)
fig.add_trace(
    go.Bar(
        x=grouped_df_nb["Recall"],
        name="Recall - SGD Classifier",
    )
)
fig.add_trace(
    go.Bar(
        x=grouped_df_sgd["Recall"],
        name="Recall - Naive Bayes",
    )
)

fig.show()

Resultados dos Modelos

De acordo com os gráficos acima, é evidente que o Random Forest Classifier possui desempenho superior à todos os seus concorrentes quando se trata de precision, recall e accuracy. Nesse sentido, os próximos passos do modelo procuram entender como otimizar os parâmetros do Random Forest Classifier de forma à alcançar resultados ainda melhores.

Feature Importances

Com o melhor modelo escolhido decidimos fazer uma análise das variáveis com mais e menos importância para o modelo

import numpy as np
import plotly.express as px


def get_feature_importances(model):
    cat_cols = full_pipeline.transformers_[1][1]["cat_encoder"].get_feature_names(
        cat_attribs
    )
    num_cols = num_attribs
    cols = np.concatenate((num_cols, cat_cols))
    df_feat_importances = pd.DataFrame(
        {"Stats": cols, "FI": model.feature_importances_}
    ).sort_values(by="FI", ascending=0)
    figLeast = px.bar_polar(
        df_feat_importances.iloc[-12:],
        r="FI",
        theta="Stats",
        color="Stats",
        template="plotly_dark",
        color_discrete_sequence=px.colors.sequential.Plasma_r,
    )
    figMost = px.bar_polar(
        df_feat_importances.iloc[:12],
        r="FI",
        theta="Stats",
        color="Stats",
        template="plotly_dark",
        color_discrete_sequence=px.colors.sequential.Plasma_r,
    )
    return (figLeast, figMost)

figs = [
    #   Other models dont have feature importances
    get_feature_importances(rf_classifier),
]

for figLeast, figMost in figs:
    figMost.show()
    figLeast.show()

Variáveis mais importantes

• Ct_armor e t_armor Surpreendentemente as variáveis mais importantes foram as armaduras. O que faz sentido dado que além de ser algo muito importante para a sobrevivência do jogador, também é um parâmetro bom para determinar economia no jogo. No entanto o grupo não imaginou ter uma importância tão grande para o modelo.
• t_money e ct_money Como esperado CSGO é um jogo de economia, assim a variável de dinheiro dos dois lados teve grande importância também.
• time_left O tempo ser a terceira maior importância na determinação de ganhar o round também faz muito sentido dado que muitas vezes o round pode ser ganho somente no tempo.

Variáveis menos importantes

• T_force Surpreendentemente a variável criada pelo grupo de rounds forçados são as menos importantes para o modelo. Isso provavelmente se da por causa das delimitações utilizadas para criar estas colunas.
• Ct_force_weapons e t_force_weapons Assim como a delimitação de rounds forçados o numero de armas da categoria force também não teve muita importância. O que é mais surpreendente dado que elas são consideravelmente piores que as armar principais.

Grid Search

A medida de score definida para o modelo foi a "roc_auc", que mede a capacidade do modelo de distinguir as classes (round winner). Quanto maior o AUC, melhor a capacidade do modelo de prever outputs positivos e negativos, ou seja, melhor a capacidade do modelo de distinguir se uma determinada equipe vai vencer aquela rodada ou não.

from sklearn.model_selection import GridSearchCV

forest_clf = RandomForestClassifier(random_state=RANDOM_SEED)

n_estimators = [100, 200, 250, 300, 350, 400, 450, 500]
max_features = [3, 5, 8]

param_grid = [
    {
        "n_estimators": n_estimators,
        "max_features": max_features,
    },
]

grid_search = GridSearchCV(
    forest_clf,  # Modelo
    param_grid,  # Grid
    cv=5,  # Partições de C.V.
    scoring="roc_auc",  # accuracy, recall, precision
    return_train_score=True,
    n_jobs=-1,
)

grid_search.fit(X_train, y_train)

GridSearchCV(cv=5, estimator=RandomForestClassifier(random_state=420),
             n_jobs=-1,
             param_grid=[{'max_features': [3, 5, 8],
                          'n_estimators': [100, 200, 250, 300, 350, 400, 450,
                                           500]}],
             return_train_score=True, scoring='roc_auc')

# Testing best estimators
grid_search.best_estimator_

RandomForestClassifier(max_features=3, n_estimators=500, random_state=420)

def plot_grid_search(
    cv_results, grid_param_1, grid_param_2, name_param_1, name_param_2
):
    # Get Test Scores Mean and std for each grid search
    scores_mean = cv_results["mean_test_score"]
    scores_mean = np.array(scores_mean).reshape(len(grid_param_2), len(grid_param_1))

    scores_sd = cv_results["std_test_score"]
    scores_sd = np.array(scores_sd).reshape(len(grid_param_2), len(grid_param_1))

    # Plot Grid search scores
    _, ax = plt.subplots(1, 1)

    # Param1 is the X-axis, Param 2 is represented as a different curve (color line)
    for idx, val in enumerate(grid_param_2):
        ax.plot(
            grid_param_1,
            scores_mean[idx, :],
            "-o",
            label=name_param_2 + ": " + str(val),
        )

    ax.set_title("Grid Search Scores", fontsize=20, fontweight="bold")
    ax.set_xlabel(name_param_1, fontsize=16)
    ax.set_ylabel("CV Average Score", fontsize=16)
    ax.legend(loc="best", fontsize=15)
    ax.grid("on")


# Calling Method
plot_grid_search(
    grid_search.cv_results_, n_estimators, max_features, "N Estimators", "Max Features"
)

De acordo com o gráfico acima, após o treinamento do modelo utilizando diversos parâmetros de n_estimators e max_features, é possível chegar em duas conclusões:

• Quanto menor a quantidade de features, maior o score AUC do modelo.
• Quanto maior a quantidade de estimators, maior o score AUC do modelo.

Nesse sentido, ainda é possível continuar otimizando os parâmetros do modelo ao testar novos valores para estas variáveis.